.TH "/media/store/Informatica/C_C++/Projects_Linux/TorTella_gnu/src/servent.h" 3 "19 Jun 2008" "Version 0.1" "TorTella" \" -*- nroff -*-
.ad l
.nh
.SH NAME
/media/store/Informatica/C_C++/Projects_Linux/TorTella_gnu/src/servent.h \- 
.SH SYNOPSIS
.br
.PP
\fC#include 'common.h'\fP
.br
\fC#include 'packetmanager.h'\fP
.br
\fC#include 'utils.h'\fP
.br
\fC#include 'datamanager.h'\fP
.br
\fC#include 'init.h'\fP
.br
\fC#include 'routemanager.h'\fP
.br
\fC#include <pthread.h>\fP
.br
\fC#include <signal.h>\fP
.br
\fC#include <unistd.h>\fP
.br
\fC#include 'controller.h'\fP
.br
\fC#include <glib.h>\fP
.br
\fC#include 'logger.h'\fP
.br
\fC#include 'confmanager.h'\fP
.br
\fC#include <time.h>\fP
.br
\fC#include <sys/stat.h>\fP
.br
\fC#include <string.h>\fP
.br

.SS "Strutture dati"

.in +1c
.ti -1c
.RI "struct \fBservent_data\fP"
.br
.RI "\fITale struttura dati viene utilizzata per le operazioni di comunicazioni con un servente a cui si e' connessi. \fP"
.in -1c
.SS "Definizioni"

.in +1c
.ti -1c
.RI "#define \fB_GNU_SOURCE\fP"
.br
.ti -1c
.RI "#define \fBTIMEOUT\fP   'timeout error'"
.br
.ti -1c
.RI "#define \fBWLOCK\fP(servent)"
.br
.RI "\fILista identificatori server thread connessi. \fP"
.ti -1c
.RI "#define \fBRLOCK\fP(servent)"
.br
.ti -1c
.RI "#define \fBUNLOCK\fP(servent)"
.br
.ti -1c
.RI "#define \fBUNLOCK_F\fP(servent)"
.br
.ti -1c
.RI "#define \fBCOPY_SERVENT\fP(servent, copy)"
.br
.RI "\fITale macro viene utilizzata per copiare un \fBservent_data\fP in un altro. \fP"
.in -1c
.SS "Ridefinizioni di tipo (typedef)"

.in +1c
.ti -1c
.RI "typedef struct \fBservent_data\fP \fBservent_data\fP"
.br
.in -1c
.SS "Funzioni"

.in +1c
.ti -1c
.RI "int \fBservent_create_server\fP (char *src_ip, \fBu_int4\fP src_port)"
.br
.RI "\fICrea un server socket. \fP"
.ti -1c
.RI "int \fBservent_create_client\fP (char *dst_ip, \fBu_int4\fP dst_port)"
.br
.RI "\fICrea un client socket. \fP"
.ti -1c
.RI "int \fBservent_start_server\fP (char *\fBlocal_ip\fP, \fBu_int4\fP \fBlocal_port\fP)"
.br
.RI "\fIAvvia il server thread che viene usato per accettare le nuove connessioni e quindi lanciare nuovi thread per gestirle. \fP"
.ti -1c
.RI "\fBservent_data\fP * \fBservent_start_client\fP (char *dest_ip, \fBu_int4\fP dest_port, \fBu_int8\fP id)"
.br
.RI "\fIAvvia un client thread usato per gestire tutte le richieste di invio pacchetti al peer associato. \fP"
.ti -1c
.RI "int \fBservent_start\fP (GList *init_servent)"
.br
.RI "\fIQuesta funzione viene utilizzata per il boot iniziale, in quanto si connette alla lista dei peer conosciuti, presi dal file di init. \fP"
.ti -1c
.RI "int \fBservent_start_timer\fP (void)"
.br
.RI "\fITale funzione non fa altro che avviare il timer thread utilizzato per supportare il meccanismo di failure detection. \fP"
.ti -1c
.RI "int \fBservent_init_connection\fP (GList *init_servent)"
.br
.RI "\fISi connette alla lista dei peer specificati, se qualcuno non e' disponibile lo salta. \fP"
.ti -1c
.RI "void \fBservent_close_all\fP (void)"
.br
.RI "\fIQuesta funzione viene chiamata alla chiusura di TorTella, serve per chiudere tutti i socket aperti (non brutalmente). \fP"
.ti -1c
.RI "void \fBservent_kill_all_thread\fP (int sig)"
.br
.RI "\fIUltima funzione chiamata alla chiusura del programma, termina tutti i thread attivi. \fP"
.ti -1c
.RI "int \fBservent_init\fP (char *ip, \fBu_int4\fP port, \fBu_int1\fP status)"
.br
.RI "\fIInizializza: le variabili del peer locale, il seed, le hashtable, i lock etc. \fP"
.ti -1c
.RI "void \fBservent_init_supernode\fP ()"
.br
.RI "\fIFunzione utilizzata per il recupero delle \fBchat\fP conosciute da file, attualmente non piu' utilizzata. \fP"
.ti -1c
.RI "void \fBservent_close_supernode\fP ()"
.br
.RI "\fIFunzione utilizzata per il salvataggio delle \fBchat\fP conosciute su file, attualmente non piu' utilizzata. \fP"
.ti -1c
.RI "\fBservent_data\fP * \fBservent_get\fP (\fBu_int8\fP id)"
.br
.RI "\fI-----Gestione servent_data----- \fP"
.ti -1c
.RI "GList * \fBservent_get_values\fP (void)"
.br
.RI "\fIRestituisce la lista completa delle \fBservent_data\fP. \fP"
.ti -1c
.RI "GList * \fBservent_get_keys\fP (void)"
.br
.RI "\fIRestituisce la lista completa delle chiavi associate alle \fBservent_data\fP. \fP"
.ti -1c
.RI "\fBservent_data\fP * \fBservent_get_local\fP (void)"
.br
.RI "\fIRestituisce la \fBservent_data\fP del peer locale. \fP"
.ti -1c
.RI "void \fBservent_send_packet\fP (\fBservent_data\fP *sd)"
.br
.RI "\fI-----Gestione Queue----- \fP"
.ti -1c
.RI "\fBservent_data\fP * \fBservent_pop_queue\fP (\fBservent_data\fP *sd)"
.br
.RI "\fIRimuove dalla coda di pacchetti da inviare ad uno specifico peer. \fP"
.ti -1c
.RI "void \fBservent_append_response\fP (\fBservent_data\fP *sd, const char *response)"
.br
.RI "\fIAppende alla coda di risposta di uno specifico peer. \fP"
.ti -1c
.RI "char * \fBservent_pop_response\fP (\fBservent_data\fP *sd)"
.br
.RI "\fIRimuove dalla coda di risposta un elemento se presente, nel frattempo avvia un timer per rilevare eventuali timeout di risposta. \fP"
.ti -1c
.RI "void \fBservent_flush_data\fP (void)"
.br
.RI "\fIPulisce la lista dei pacchetti ricevuti che serve per scartare pacchetti con ID uguale a quelli ricevuti recentemente. \fP"
.ti -1c
.RI "char * \fBservent_get_search_packet\fP (\fBu_int8\fP id)"
.br
.RI "\fI-----Routing----- \fP"
.ti -1c
.RI "void \fBservent_new_search_packet\fP (\fBu_int8\fP id)"
.br
.RI "\fIAggiunge il pacchetto alla lista dei pacchetti ricevuti. \fP"
.ti -1c
.RI "char * \fBservent_get_join_packet\fP (\fBu_int8\fP id)"
.br
.RI "\fIRitorna l'ID del pacchetto richiesto, se presente. \fP"
.ti -1c
.RI "void \fBservent_new_join_packet\fP (\fBu_int8\fP id)"
.br
.RI "\fIAggiunge il pacchetto alla lista dei pacchetti ricevuti. \fP"
.ti -1c
.RI "char * \fBservent_get_leave_packet\fP (\fBu_int8\fP id)"
.br
.RI "\fIRitorna l'ID del pacchetto richiesto, se presente. \fP"
.ti -1c
.RI "void \fBservent_new_leave_packet\fP (\fBu_int8\fP id)"
.br
.RI "\fIAggiunge il pacchetto alla lista dei pacchetti ricevuti. \fP"
.ti -1c
.RI "void * \fBservent_listen\fP (void *parm)"
.br
.RI "\fI---------THREAD--------------- \fP"
.ti -1c
.RI "void * \fBservent_respond\fP (void *parm)"
.br
.RI "\fIServer thread che riceve i pacchetti e risponde adeguatamente. \fP"
.ti -1c
.RI "void * \fBservent_connect\fP (void *parm)"
.br
.RI "\fIClient thread utilizzato per gestire il canale di invio pacchetti ad un peer. \fP"
.ti -1c
.RI "void * \fBservent_timer\fP (void *parm)"
.br
.RI "\fIThread utilizzato per gestire il meccanismo di failure detection e per pulire la lista dei pacchetti ricevuti. \fP"
.in -1c
.SS "Variabili"

.in +1c
.ti -1c
.RI "static GHashTable * \fBservent_hashtable\fP"
.br
.ti -1c
.RI "static GHashTable * \fBsearch_packet_hashtable\fP = NULL"
.br
.RI "\fIHashtable di \fBservent_data\fP, una per ogni peer. \fP"
.ti -1c
.RI "static GHashTable * \fBjoin_packet_hashtable\fP = NULL"
.br
.ti -1c
.RI "static GHashTable * \fBleave_packet_hashtable\fP = NULL"
.br
.ti -1c
.RI "static \fBservent_data\fP * \fBlocal_servent\fP"
.br
.RI "\fI--------------------------- \fP"
.ti -1c
.RI "static \fBu_int8\fP \fBnew_connection_counter\fP"
.br
.RI "\fIDati del peer locale. \fP"
.ti -1c
.RI "static pthread_t * \fBtimer_thread\fP"
.br
.RI "\fILimite inferiore generazione ID. \fP"
.ti -1c
.RI "static GList * \fBclient_fd\fP"
.br
.RI "\fIidentificatore timer thread; \fP"
.ti -1c
.RI "static GList * \fBserver_fd\fP"
.br
.RI "\fILista client socket. \fP"
.ti -1c
.RI "static GList * \fBserver_connection_fd\fP"
.br
.RI "\fILista server socket in attesa di connessioni. \fP"
.ti -1c
.RI "static GList * \fBclient_thread\fP"
.br
.RI "\fILista server socket connessi. \fP"
.ti -1c
.RI "static GList * \fBserver_thread\fP"
.br
.RI "\fILista identificatori client thread. \fP"
.ti -1c
.RI "static GList * \fBserver_connection_thread\fP"
.br
.RI "\fILista identificatori server thread in attesa di connessioni. \fP"
.in -1c
.SH "Documentazione delle definizioni"
.PP 
.SS "#define _GNU_SOURCE"
.PP
Definizione alla linea 36 del file servent.h.
.SS "#define COPY_SERVENT(servent, copy)"
.PP
\fBValore:\fP
.PP
.nf
copy=calloc(1, sizeof(servent_data)); \
                                                                                        memcpy(copy, servent, sizeof(servent_data))
.fi
Tale macro viene utilizzata per copiare un \fBservent_data\fP in un altro. 
.PP
Definizione alla linea 149 del file servent.h.
.SS "#define RLOCK(servent)"
.PP
\fBValore:\fP
.PP
.nf
logger(SYS_INFO, '[RLOCK]Try locking %lld\n', servent); \
                                                                if(servent_get(servent)!=NULL) { \
                                                                        pthread_rwlock_rdlock( &((servent_get(servent)->rwlock_data))); \
                                                                        logger(SYS_INFO, '[RLOCK]Lock %lld\n', servent); \
                                                                }
.fi
.PP
Definizione alla linea 133 del file servent.h.
.SS "#define TIMEOUT   'timeout error'"
.PP
Definizione alla linea 55 del file servent.h.
.SS "#define UNLOCK(servent)"
.PP
\fBValore:\fP
.PP
.nf
logger(SYS_INFO, '[UNLOCK]Try unlocking %lld\n', servent); \
                                                                if(servent_get(servent)!=NULL) { \
                                                                        pthread_rwlock_unlock( &((servent_get(servent)->rwlock_data))); \
                                                                        logger(SYS_INFO, '[UNLOCK]Unlock %lld\n', servent); \
                                                                }
.fi
.PP
Definizione alla linea 139 del file servent.h.
.SS "#define UNLOCK_F(servent)"
.PP
\fBValore:\fP
.PP
.nf
pthread_rwlock_unlock( &(((servent)->rwlock_data)) ); \
                                                                logger(SYS_INFO, '[UNLOCK_F]Unlock %lld\n', servent->id);
.fi
.PP
Definizione alla linea 145 del file servent.h.
.SS "#define WLOCK(servent)"
.PP
\fBValore:\fP
.PP
.nf
logger(SYS_INFO, '[WLOCK]Try locking %lld\n', servent); \
                                                                if(servent_get(servent)!=NULL) { \
                                                                        pthread_rwlock_wrlock( &((servent_get(servent)->rwlock_data))); \
                                                                        logger(SYS_INFO, '[WLOCK]Lock %lld\n', servent); \
                                                                }
.fi
Lista identificatori server thread connessi. 
.PP
Macro di utilita' 
.PP
Definizione alla linea 127 del file servent.h.
.SH "Documentazione delle ridefinizioni di tipo (typedef)"
.PP 
.SS "typedef struct \fBservent_data\fP \fBservent_data\fP"
.PP
Definizione alla linea 97 del file servent.h.
.SH "Documentazione delle funzioni"
.PP 
.SS "void servent_append_response (\fBservent_data\fP * sd, const char * response)"
.PP
Appende alla coda di risposta di uno specifico peer. 
.PP
In particolare aggiunge la risposta ricevuta dopo l'invio di un pacchetto. 
.PP
Definizione alla linea 331 del file servent.c.
.SS "void servent_close_all (void)"
.PP
Questa funzione viene chiamata alla chiusura di TorTella, serve per chiudere tutti i socket aperti (non brutalmente). 
.PP
Definizione alla linea 161 del file servent.c.
.SS "void servent_close_supernode ()"
.PP
Funzione utilizzata per il salvataggio delle \fBchat\fP conosciute su file, attualmente non piu' utilizzata. 
.PP

.PP
write_all(MODE_TRUNC); 
.PP
Definizione alla linea 264 del file servent.c.
.SS "void* servent_connect (void * parm)"
.PP
Client thread utilizzato per gestire il canale di invio pacchetti ad un peer. 
.PP

.PP
Si prendono l'ip e la porta dalla lista degli id
.PP
Creazione socket client
.PP
Aggiunta richiesta di PING nella coda del suddetto servent per iniziare la connessione verso il server.
.PP
Ora si entra nel ciclo infinito che serve per inviare tutte le richieste
.PP
Attesa richiesta di invio pacchetto
.PP
Questo passo e' fondamentale quando si effettua la connessione iniziale, Quando viene inviato il nuovo ID tramite PING.
.PP
Si salvano tutti i dati nella struttura dati condivisa
.PP
Invio dei vari pacchetti
.PP
Invio di pacchetto GET (non utilizzata) send_get_request_packet(fd, char *filename, u_int4 range_start, u_int4 range_end);
.PP
Richiesta di invio CLOSE, ovvero terminazione thread corrente
.PP
Converte la lista delle \fBchat\fP in stringa, per inviare tramite pacchetto
.PP
Attesa ricezione risposta
.PP
Appende alla coda delle risposte il tipo di risposta ricevuta
.PP
In caso di timeout appende alla coda delle risposte l'errore 
.PP
Definizione alla linea 1017 del file servent.c.
.SS "int servent_create_client (char * dst_ip, \fBu_int4\fP dst_port)"
.PP
Crea un client socket. 
.PP
Definizione alla linea 30 del file servent.c.
.SS "int servent_create_server (char * src_ip, \fBu_int4\fP src_port)"
.PP
Crea un server socket. 
.PP
Definizione alla linea 22 del file servent.c.
.SS "void servent_flush_data (void)"
.PP
Pulisce la lista dei pacchetti ricevuti che serve per scartare pacchetti con ID uguale a quelli ricevuti recentemente. 
.PP
Definizione alla linea 413 del file servent.c.
.SS "\fBservent_data\fP* servent_get (\fBu_int8\fP id)"
.PP
-----Gestione servent_data----- 
.PP
Restituisce il \fBservent_data\fP associato all'id richiesto. 
.PP
Definizione alla linea 273 del file servent.c.
.SS "char* servent_get_join_packet (\fBu_int8\fP id)"
.PP
Ritorna l'ID del pacchetto richiesto, se presente. 
.PP
E' una sorta di verifica presenta pacchetto. Utilizzato per gestire i duplicati. 
.PP
Definizione alla linea 382 del file servent.c.
.SS "GList* servent_get_keys (void)"
.PP
Restituisce la lista completa delle chiavi associate alle \fBservent_data\fP. 
.PP
Definizione alla linea 287 del file servent.c.
.SS "char* servent_get_leave_packet (\fBu_int8\fP id)"
.PP
Ritorna l'ID del pacchetto richiesto, se presente. 
.PP
E' una sorta di verifica presenta pacchetto. Utilizzato per gestire i duplicati. 
.PP
Definizione alla linea 398 del file servent.c.
.SS "\fBservent_data\fP* servent_get_local (void)"
.PP
Restituisce la \fBservent_data\fP del peer locale. 
.PP
Definizione alla linea 294 del file servent.c.
.SS "char* servent_get_search_packet (\fBu_int8\fP id)"
.PP
-----Routing----- 
.PP
Ritorna l'ID del pacchetto richiesto, se presente. E' una sorta di verifica presenta pacchetto. Utilizzato per gestire i duplicati. 
.PP
Definizione alla linea 366 del file servent.c.
.SS "GList* servent_get_values (void)"
.PP
Restituisce la lista completa delle \fBservent_data\fP. 
.PP
Definizione alla linea 280 del file servent.c.
.SS "int servent_init (char * ip, \fBu_int4\fP port, \fBu_int1\fP status)"
.PP
Inizializza: le variabili del peer locale, il seed, le hashtable, i lock etc. 
.PP
.. 
.PP
Inizializza la lista delle \fBchat\fP conosciute leggendo da un file predefinito (non utilizzato)
.PP
Inizializza il seed
.PP
Recupera il numero iniziale da cui generare fake ID
.PP
----Routing-----
.PP
----------------
.PP
Aggiunta utente locale alle liste di utenti conosciuti 
.PP
Definizione alla linea 205 del file servent.c.
.SS "int servent_init_connection (GList * init_servent)"
.PP
Si connette alla lista dei peer specificati, se qualcuno non e' disponibile lo salta. 
.PP
Definizione alla linea 144 del file servent.c.
.SS "void servent_init_supernode ()"
.PP
Funzione utilizzata per il recupero delle \fBchat\fP conosciute da file, attualmente non piu' utilizzata. 
.PP

.PP
\fBread_all()\fP; 
.PP
Definizione alla linea 256 del file servent.c.
.SS "void servent_kill_all_thread (int sig)"
.PP
Ultima funzione chiamata alla chiusura del programma, termina tutti i thread attivi. 
.PP

.PP
Viene utilizzata per il salvataggio delle \fBchat\fP su file (non utilizzata) 
.PP
Definizione alla linea 181 del file servent.c.
.SS "void* servent_listen (void * parm)"
.PP
---------THREAD--------------- 
.PP
Thread che riceve le richieste di connessione e avvia nuovi thread. Ogni nuovo peer (client) che richiede di connettersi al server locale viene assegnato ad un nuovo Thread che si occupera' di rispondere alle richieste del client. 
.PP
Aggiunge alla lista dei socket descriptor di connessione
.PP
Avvia il server thread
.PP
Aggiunge alla lista degli identificatori dei thread di connessione 
.PP
Definizione alla linea 427 del file servent.c.
.SS "void servent_new_join_packet (\fBu_int8\fP id)"
.PP
Aggiunge il pacchetto alla lista dei pacchetti ricevuti. 
.PP
Definizione alla linea 389 del file servent.c.
.SS "void servent_new_leave_packet (\fBu_int8\fP id)"
.PP
Aggiunge il pacchetto alla lista dei pacchetti ricevuti. 
.PP
Definizione alla linea 405 del file servent.c.
.SS "void servent_new_search_packet (\fBu_int8\fP id)"
.PP
Aggiunge il pacchetto alla lista dei pacchetti ricevuti. 
.PP
Definizione alla linea 373 del file servent.c.
.SS "\fBservent_data\fP* servent_pop_queue (\fBservent_data\fP * sd)"
.PP
Rimuove dalla coda di pacchetti da inviare ad uno specifico peer. 
.PP
Se non ci sono pacchetti da rimuovere rimane in attesa. 
.PP
Ciclo utilizzato per attendere la richiesta di invio pacchetti
.PP
Attende prima di controllare di nuovo la coda 
.PP
Definizione alla linea 314 del file servent.c.
.SS "char* servent_pop_response (\fBservent_data\fP * sd)"
.PP
Rimuove dalla coda di risposta un elemento se presente, nel frattempo avvia un timer per rilevare eventuali timeout di risposta. 
.PP

.PP
Contatore utilizzato per dare un timeout al superamento di una soglia
.PP
Serve per il timeout 
.PP
Definizione alla linea 340 del file servent.c.
.SS "void* servent_respond (void * parm)"
.PP
Server thread che riceve i pacchetti e risponde adeguatamente. 
.PP
Ne esiste uno per ogni peer a cui si e' connessi. Questa funzione e' il vero cuore di TorTella, infatti gestisce tutti i comportamente dei programma in base ai pacchetti ricevuti.
.PP
\fBParametri:\fP
.RS 4
\fIparm\fP Socket descriptor della connessione 
.RE
.PP

.PP
Attesa ricezione pacchetto HTTP
.PP
Riempimento della struttura dati \fBhttp_packet\fP con i valori ricevuti
.PP
Effettua le operazioni adeguatamente al tipo di pacchetto ricevuto
.PP
Imposta lo status del pacchetto di risposta da inviare
.PP
Entra in questa condizione se l'ID di ricezione del pacchetto e' diverso dal locale, ovvero il pacchetto non e' destinato al peer che l'ha ricevuto. Inoltre controlla che l'ID non sia falso.
.PP
Invio di un pacchetto di notifica di avvenuta ricezione del JOIN
.PP
Si imposta lo status a 0 per evitare di inviare un doppio pacchetto di notifica
.PP
Verifica che il pacchetto ricevuto non sia un duplicato
.PP
Aggiunge il pacchetto ricevuto all'hashtable associata al JOIN
.PP
Aggiunta dell'utente che ha inviato il JOIN nelle liste contenenti gli utenti
.PP
Verifica che il ttl sia maggiore di uno per il rinvio del pacchetto agli altri peer
.PP
Recupero di tutti i peer a cui si e' connessi per rinviare il pacchetto (flooding)
.PP
Evita di rinviare il pacchetto al peer da cui ha ricevuto il JOIN. Evita di inviare il pacchetto due volte ad uno stesso peer.
.PP
Invio del pacchetto al peer selezionato
.PP
Attesa ricezione risposta
.PP
invio del pacchetto di OK
.PP
Controlla che il peer che ha inviato il pacchetto sia conosciuto e quindi viene interpretato come un semplice ping inviato per gestire il meccanismo di failure detection o il cambio di status.
.PP
notifica del cambio di status sulla gui. Presi i lock sulla gui per consentire l'accesso protetto ai dati della gui.
.PP
Entra in questo flusso quando il peer mittente non e' ancora conosciuto dal peer locale. Serve per stabilire una nuova connesione tra i due peer.
.PP
controllo che l'id del mittente sia falso in modo da capire che e' la richiesta di una nuova connessione
.PP
aggiunta dell'utente alla lista dei peer conosciuti.
.PP
Si inizializza il mutex
.PP
creazione nuovo client thread per gestire la connessione con il nuovo peer.
.PP
attesa risposta di OK (o TIMEOUT).
.PP
Rappresenta la seconda fase della connessione ad un peer. Esempio: il peer locale invia un ping con id falso ad un peer con cui vuole stabilire la connessione; il peer remoto invia un ping con il vero id. Connessione stabilita.
.PP
recupera la \fBservent_data\fP associata al precedente fake id e sostituisce il falso id con quello reale.
.PP
rimuove dalla hashtable la chiave con id fasullo
.PP
aggiunge l'utente alla lista dei peer conosciuti
.PP
Ricezione di un pacchetto di tipo LEAVE.
.PP
invio di un pacchetto di OK che conferma l'avvenuta ricezione del LEAVE
.PP
controllo dei pacchetti LEAVE duplicati
.PP
aggiunge il pacchetto alla lista dei pacchetti LEAVE
.PP
Sconnetti dalla \fBchat\fP l'utente
.PP
controllo che il TTL sia maggiore di uno in modo da reinviare il pacchetto
.PP
Evita di rinviare il pacchetto al peer da cui ha ricevuto il LEAVE. Evita di inviare il pacchetto due volte ad uno stesso peer.
.PP
invio del pacchetto al peer selezionato
.PP
attesa della ricezione del messaggio di OK (o di TIMEOUT)
.PP
Ricezione di un pacchetto di tipo MESSAGE.
.PP
prepara il messaggio in modo da aggiornare la GUI
.PP
aggiornamento della gui relativa ad un messaggio privato
.PP
aggiornamento della gui relativa alla \fBchat\fP
.PP
Ricezione di un messaggio di tipo SEARCH.
.PP
invio di un mpacchetto di avvenuta ricezione della SEARCH
.PP
controllo dei pacchetti SEARCH duplicati
.PP
aggiunge il pacchetto alla lista dei pacchetti LEAVE
.PP
controllo dell'integrita' del pacchetto
.PP
Ricerca nelle \fBchat\fP conosciute la \fBchat\fP richiesta dalla SEARCH
.PP
Passa i risultati alla \fBservent_data\fP del peer remoto
.PP
invio del pacchetto SEARCHHITS
.PP
controllo che il TTL sia maggiore di uno in modo da reinviare il pacchetto
.PP
Evita di rinviare il pacchetto al peer da cui ha ricevuto il LEAVE. Evita di inviare il pacchetto due volte ad uno stesso peer.
.PP
reinvio del pacchetto SEARCH al peer selezionato
.PP
Aggiunta regola di routing alla tabella
.PP
Ricezione di un pacchetto di tipo SEARCHHITS
.PP
invio di un pacchetto di avvenuta ricezione del SEARCHHITS
.PP
Converte la stringa dei risultati ricevuti in una lista di \fBchat\fP con i relativi utenti.
.PP
Aggiunge le \fBchat\fP alle liste locali
.PP
Ritorna la regola di routing associata all'ID del pacchetto
.PP
Entra se la regola esiste
.PP
Invia il pacchetto SEARCHHITS al peer presente nella regola di routing
.PP
Elimina la regola o decrementa
.PP
Se la regola non esiste vuol dire che il peer e' colui che ha fatto la richiesta iniziale
.PP
Aggiunge la \fBchat\fP alla lista dei risultati nella GUI
.PP
Invia il pacchetto di risposta
.PP
Chiusura thread connessione
.PP
Chiusura eventuali finestre PM
.PP
Rimozione dalle strutture dati
.PP
Chiusura forzata socket
.PP
Esce dal server thread
.PP
Invio la conferma di ricezione
.PP
Chiude il client thread associato al peer
.PP
Rimuove il peer dalla GUI e dalle strutture dati
.PP
Chiusura forzata socket 
.PP
Definizione alla linea 454 del file servent.c.
.SS "void servent_send_packet (\fBservent_data\fP * sd)"
.PP
-----Gestione Queue----- 
.PP
Aggiunge alla coda di pacchetti da inviare ad uno specifico peer. In particolare si passa una \fBservent_data\fP contenete tutti i dati necessari all'invio del pacchetto. 
.PP
Definizione alla linea 305 del file servent.c.
.SS "int servent_start (GList * init_servent)"
.PP
Questa funzione viene utilizzata per il boot iniziale, in quanto si connette alla lista dei peer conosciuti, presi dal file di init. 
.PP
Inoltre inizializza tutte le variabili necessarie e avvia il server di ascolto nuove connessioni.
.PP
\fBParametri:\fP
.RS 4
\fIinit_servent\fP Lista dei serventi necessari per il boot iniziale 
.RE
.PP

.PP
Inizializzazione servent locale
.PP
Avvio server di ascolto richieste
.PP
Fase iniziale di reperimento degli utenti iniziali 
.PP
Definizione alla linea 107 del file servent.c.
.SS "\fBservent_data\fP* servent_start_client (char * dest_ip, \fBu_int4\fP dest_port, \fBu_int8\fP id)"
.PP
Avvia un client thread usato per gestire tutte le richieste di invio pacchetti al peer associato. 
.PP
\fBParametri:\fP
.RS 4
\fIid\fP Se si conosce l'id del peer a cui connettersi lo si specifica, altrimenti 0. 
.RE
.PP

.PP
Incrementa il contatore degli ID falsi
.PP
Verifica che l'id inserito non sia falso (condizione di sicurezza)
.PP
Inizializzazione dati del peer all'interno della \fBservent_data\fP
.PP
Aggiunge il peer all'elenco degli utenti conosciuti (ma non necessariamente connessi)
.PP
Aggiunge la \fBservent_data\fP generata alla hashtable dei serventi
.PP
Lancia il client thread associato al peer
.PP
Attende l'avvenuta ricezione del messaggio di OK (o timeout) 
.PP
Definizione alla linea 62 del file servent.c.
.SS "int servent_start_server (char * local_ip, \fBu_int4\fP local_port)"
.PP
Avvia il server thread che viene usato per accettare le nuove connessioni e quindi lanciare nuovi thread per gestirle. 
.PP

.PP
Avvia il server di ascolto
.PP
Aggiunta socket descriptor alle liste 
.PP
Definizione alla linea 40 del file servent.c.
.SS "int servent_start_timer (void)"
.PP
Tale funzione non fa altro che avviare il timer thread utilizzato per supportare il meccanismo di failure detection. 
.PP
Definizione alla linea 135 del file servent.c.
.SS "void* servent_timer (void * parm)"
.PP
Thread utilizzato per gestire il meccanismo di failure detection e per pulire la lista dei pacchetti ricevuti. 
.PP
L'intervallo di tempo e' impostato nel file di configurazione. 
.PP
Invio PING al peer selezionato
.PP
Attende la risposta
.PP
Entra in questo flusso se c'e' stato un timeout (failure detection)
.PP
Elimina il peer dalla GUI e dalle strutture dati
.PP
Uccide il client thread associato al peer
.PP
Libera le hashtable dei pacchetti 
.PP
Definizione alla linea 1222 del file servent.c.
.SH "Documentazione delle variabili"
.PP 
.SS "GList* \fBclient_fd\fP\fC [static]\fP"
.PP
identificatore timer thread; 
.PP
Definizione alla linea 117 del file servent.h.
.SS "GList* \fBclient_thread\fP\fC [static]\fP"
.PP
Lista server socket connessi. 
.PP
Definizione alla linea 121 del file servent.h.
.SS "GHashTable* \fBjoin_packet_hashtable\fP = NULL\fC [static]\fP"
.PP
Definizione alla linea 105 del file servent.h.
.SS "GHashTable* \fBleave_packet_hashtable\fP = NULL\fC [static]\fP"
.PP
Definizione alla linea 107 del file servent.h.
.SS "\fBservent_data\fP* \fBlocal_servent\fP\fC [static]\fP"
.PP
--------------------------- 
.PP
Definizione alla linea 111 del file servent.h.
.SS "\fBu_int8\fP \fBnew_connection_counter\fP\fC [static]\fP"
.PP
Dati del peer locale. 
.PP
Definizione alla linea 113 del file servent.h.
.SS "GHashTable* \fBsearch_packet_hashtable\fP = NULL\fC [static]\fP"
.PP
Hashtable di \fBservent_data\fP, una per ogni peer. 
.PP
---Routing Hashtables----- 
.PP
Definizione alla linea 103 del file servent.h.
.SS "GHashTable* \fBservent_hashtable\fP\fC [static]\fP"
.PP
Definizione alla linea 99 del file servent.h.
.SS "GList* \fBserver_connection_fd\fP\fC [static]\fP"
.PP
Lista server socket in attesa di connessioni. 
.PP
Definizione alla linea 119 del file servent.h.
.SS "GList* \fBserver_connection_thread\fP\fC [static]\fP"
.PP
Lista identificatori server thread in attesa di connessioni. 
.PP
Definizione alla linea 123 del file servent.h.
.SS "GList* \fBserver_fd\fP\fC [static]\fP"
.PP
Lista client socket. 
.PP
Definizione alla linea 118 del file servent.h.
.SS "GList* \fBserver_thread\fP\fC [static]\fP"
.PP
Lista identificatori client thread. 
.PP
Definizione alla linea 122 del file servent.h.
.SS "pthread_t* \fBtimer_thread\fP\fC [static]\fP"
.PP
Limite inferiore generazione ID. 
.PP
Definizione alla linea 115 del file servent.h.
.SH "Autore"
.PP 
Generato automaticamente da Doxygen per TorTella a partire dal codice sorgente.
